package com.hzhh123.crypto.utils;

import cn.hutool.core.codec.Base64;
import cn.hutool.crypto.SecureUtil;
import cn.hutool.crypto.asymmetric.KeyType;
import cn.hutool.crypto.asymmetric.RSA;
import cn.hutool.crypto.symmetric.SymmetricAlgorithm;
import cn.hutool.crypto.symmetric.SymmetricCrypto;

import java.io.UnsupportedEncodingException;
import java.security.KeyPair;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.HashMap;
import java.util.Map;

/**
 * @author hzhh123
 * @version 1.0
 * @date 2022/4/13 11:01
 * @des
 */
public class RsaUtils {

  /**
   * 类型
   */
  public static final String ENCRYPT_TYPE = "RSA";

  /**
   * 获取公钥的key
   */
  private static final String PUBLIC_KEY = "RSAPublicKey";

  /**
   * 获取私钥的key
   */
  private static final String PRIVATE_KEY = "RSAPrivateKey";

  /**
   * 公钥加密
   *
   * @param content   要加密的内容
   * @param publicKey 公钥
   */
  public static String encrypt(String content, PublicKey publicKey) {
    try {
      RSA rsa = new RSA(null, publicKey);
      return rsa.encryptBase64(content, KeyType.PublicKey);
    } catch (Exception e) {
      e.printStackTrace();
    }
    return null;
  }

  /**
   * 公钥加密
   *
   * @param content   要加密的内容
   * @param publicKey 公钥
   */
  public static String encrypt(String content, String publicKey) {
    try {
      RSA rsa = new RSA(null, publicKey);
      return rsa.encryptBase64(content, KeyType.PublicKey);
    } catch (Exception e) {
      e.printStackTrace();
    }
    return null;
  }

  /**
   * 私钥解密
   *
   * @param content    要解密的内容
   * @param privateKey 私钥
   */
  public static String decrypt(String content, PrivateKey privateKey) {
    try {
      RSA rsa = new RSA(privateKey, null);
      return rsa.decryptStr(content, KeyType.PrivateKey);
    } catch (Exception e) {
      e.printStackTrace();
    }
    return null;
  }

  /**
   * 私钥解密
   *
   * @param content    要解密的内容
   * @param privateKey 私钥
   */
  public static String decrypt(String content, String privateKey) {
    try {
      RSA rsa = new RSA(privateKey, null);
      return rsa.decryptStr(content, KeyType.PrivateKey);
    } catch (Exception e) {
      e.printStackTrace();
    }
    return null;
  }

  /**
   * 获取公私钥-请获取一次后保存公私钥使用
   *
   * @return
   */
  public static Map<String, String> generateKeyPair() {
    try {
      KeyPair pair = SecureUtil.generateKeyPair(ENCRYPT_TYPE);
      PrivateKey privateKey = pair.getPrivate();
      PublicKey publicKey = pair.getPublic();
      // 获取 公钥和私钥 的 编码格式（通过该 编码格式 可以反过来 生成公钥和私钥对象）
      byte[] pubEncBytes = publicKey.getEncoded();
      byte[] priEncBytes = privateKey.getEncoded();

      // 把 公钥和私钥 的 编码格式 转换为 Base64文本 方便保存
      String pubEncBase64 = Base64.encode(pubEncBytes);
      String priEncBase64 = Base64.encode(priEncBytes);

      Map<String, String> map = new HashMap<String, String>(2);
      map.put(PUBLIC_KEY, pubEncBase64);
      map.put(PRIVATE_KEY, priEncBase64);

      return map;
    } catch (Exception e) {
      e.printStackTrace();
    }
    return null;
  }

  //public static void main(String[] args) throws UnsupportedEncodingException {
  //
  //  // 第一次使用时获取，获取后保存公私钥，不要重复获取
  //
  //  Map<String, String> stringStringMap = RsaUtils.generateKeyPair();
  //
  //  String RSAPublicKey = stringStringMap.get(PUBLIC_KEY);
  //
  //  String RSAPrivateKey = stringStringMap.get(PRIVATE_KEY);
  //
  //  System.out.println(RSAPublicKey);
  //  System.out.println();
  //  System.out.println();
  //  System.out.println(RSAPrivateKey);
  //
  //  SymmetricCrypto aes = new SymmetricCrypto(SymmetricAlgorithm.AES, "123456".getBytes("UTF-8"));
  //  String aesStr = aes.encryptHex("java", "UTF-8");
  //  System.out.println(aesStr);
  //}

}
